home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / Dots & Pixels / sources / streamutils.cp < prev    next >
Text File  |  1995-09-29  |  2KB  |  143 lines
  1. #include <stdlib.h>
  2. #include <ctype.h>
  3. #include <math.h>
  4. #include <assert.h>
  5. #include <string.h>
  6.  
  7. #include <Memory.h>
  8. #include <OSUtils.h>
  9.  
  10. #include <new.h>
  11. #include <iostream.h>
  12.  
  13. #include "streamutils.h"
  14.  
  15. char skip_spaces( istream &destroom)
  16. {
  17.     char result = 0;
  18.     do {
  19.         destroom.get( result);
  20.     } while( isspace( result) && (result != '\n') && destroom.good());
  21.  
  22.     if( !destroom.good())
  23.     {
  24.         //
  25.         // assume EOF, pseudo-add a newline at end
  26.         //
  27.         result = '\n';
  28.     }
  29.     return result;
  30. }
  31.  
  32. void skip_till( istream &destroom, const char theLetter)
  33. {
  34.     char letter;
  35.     do
  36.     {
  37.         destroom.get( letter);
  38.     } while( (letter != theLetter) && (destroom.good()));
  39. }
  40.  
  41. void skip_till( istream &destroom, const char *theString)
  42. {
  43.     typedef enum
  44.     {
  45.         searching,
  46.         matching,
  47.         stream_exhausted,
  48.         found_it
  49.     } search_state;
  50.     search_state the_search_state = searching;
  51.  
  52.     while( the_search_state == searching)
  53.     {
  54.         //
  55.         // to find the string, we first have to find the first character:
  56.         //
  57.         const char *current = &theString[ 0];
  58.         skip_till( destroom, *current);
  59.  
  60.         if( destroom.good())
  61.         {
  62.             the_search_state = matching;
  63.             while( the_search_state == matching)
  64.             {
  65.                 current += 1;
  66.                 if( *current == 0)
  67.                 {
  68.                     the_search_state = found_it;
  69.                 } else {
  70.                     char letter;
  71.                     destroom.get( letter);
  72.                     if( destroom.good())
  73.                     {
  74.                         if( *current != letter)
  75.                         {
  76.                             the_search_state = searching;
  77.                         }
  78.                     } else {
  79.                         the_search_state = stream_exhausted;
  80.                     }
  81.                 }
  82.             }
  83.         } else {
  84.             the_search_state = stream_exhausted;
  85.         }
  86.     }
  87. }
  88.  
  89. void copy_till( istream &is, ostream &os, const char theLetter)
  90. {
  91.     char letter;
  92.     
  93.     while( true)
  94.     {
  95.         is.get( letter);
  96.         if( !is.good() || (letter == theLetter))
  97.         {
  98.             break;
  99.         }
  100.         os.put( letter);
  101.     }
  102.     if( is.good())
  103.     {
  104.         is.putback( letter);
  105.     }
  106. }
  107.  
  108. void skip_over_newline( istream &destroom)
  109. {
  110.     char letter;
  111.     do
  112.     {
  113.         destroom.get( letter);
  114.     } while( (letter != '\n') && (destroom.good()));
  115. }
  116.  
  117. void skip_till_digit( istream &destroom)
  118. {
  119.     char letter;
  120.     do
  121.     {
  122.         destroom.get( letter);
  123.     } while( !isdigit( letter) && (destroom.good()));
  124.     if( destroom.good())
  125.     {
  126.         destroom.putback( letter);
  127.     }
  128. }
  129.  
  130. void skip_till_numberstart( istream &destroom)
  131. {
  132.     char letter;
  133.     do
  134.     {
  135.         destroom.get( letter);
  136.     } while( !is_possible_numberstart( letter) && (destroom.good()));
  137.     if( destroom.good())
  138.     {
  139.         destroom.putback( letter);
  140.     }
  141. }
  142.  
  143.